home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 5 / Apprentice-Release5.iso / Environments / PowerMacOberon feb96 / Source / POPdump.Mod (.txt) < prev    next >
Encoding:
Oberon Text  |  1994-06-20  |  14.1 KB  |  471 lines  |  [.Ob./.Ob4]
  1. Syntax10.Scn.Fnt
  2. MODULE POPdump;    (* RC 6.3.89 / 29.7.91 *)
  3.     IMPORT OP2 := Compiler, OPT := POPT, Oberon, Texts, TextFrames, Viewers, MenuViewers, Display, SYSTEM;
  4.     CONST
  5.         (* object modes *)
  6.         Var = 1; VarPar = 2; Con = 3; Fld = 4; Typ = 5; LProc = 6; XProc = 7;
  7.         SProc = 8; CProc = 9; IProc = 10; Mod = 11; Head = 12; TProc = 13;
  8.         (* symbol values and ops *)
  9.         times = 1; slash = 2; div = 3; mod = 4;
  10.         and = 5; plus = 6; minus = 7; or = 8; eql = 9;
  11.         neq = 10; lss = 11; leq = 12; gtr = 13; geq = 14;
  12.         in = 15; is = 16; ash = 17; msk = 18; len = 19;
  13.         conv = 20; abs = 21; cap = 22; odd = 23; not = 33;
  14.         (*SYSTEM*)
  15.         adr = 24; cc = 25; bit = 26; lsh = 27; rot = 28; val = 29;
  16.         (* structure forms *)
  17.         Undef = 0; Byte = 1; Bool = 2; Char = 3; SInt = 4; Int = 5; LInt = 6;
  18.         Real = 7; LReal = 8; Set = 9; String = 10; NilTyp = 11; NoTyp = 12;
  19.         Pointer = 13; ProcTyp = 14; Comp = 15;
  20.         (* composite structure forms *)
  21.         Basic = 1; Array = 2; DynArr = 3; Record = 4;
  22.         (* nodes classes *)
  23.         Nvar = 0; Nvarpar = 1; Nfield = 2; Nderef = 3; Nindex = 4; Nguard = 5; Neguard = 6;
  24.         Nconst = 7; Ntype = 8; Nproc = 9; Nupto = 10; Nmop = 11; Ndop = 12; Ncall = 13;
  25.         Ninittd = 14; Nif = 15; Ncaselse = 16; Ncasedo = 17; Nenter = 18; Nassign = 19;
  26.         Nifelse = 20; Ncase = 21; Nwhile = 22; Nrepeat = 23; Nloop = 24; Nexit = 25;
  27.         Nreturn = 26; Nwith = 27; Ntrap = 28;
  28.         (*function number*)
  29.         assign = 0; newfn = 1; incfn = 13; decfn = 14;
  30.         inclfn = 15; exclfn = 16; copyfn = 18;
  31.         (*SYSTEM function number*)
  32.         getfn = 24; putfn = 25; getrfn = 26; putrfn = 27; sysnewfn = 30; movefn = 31;
  33.         v: Viewers.Viewer;
  34.         w: Texts.Writer;
  35.         t: Texts.Text;
  36.         allocated: BOOLEAN;
  37.         pl: ARRAY 16384 OF LONGINT;
  38.         plx: INTEGER;
  39.         typform: ARRAY 16, 10 OF CHAR;
  40.         typcomp: ARRAY 5, 10 OF CHAR;
  41.         op: ARRAY 34, 10 OF CHAR;
  42.         pmode: ARRAY 14, 10 OF CHAR;
  43.         fn: ARRAY 32, 10 OF CHAR;
  44.     PROCEDURE OpenViewer;
  45.         VAR x, y: INTEGER;
  46.     BEGIN
  47.         Oberon.AllocateSystemViewer(0, x, y);
  48.         t:=TextFrames.Text("");
  49.         v:=MenuViewers.New(
  50.             TextFrames.NewMenu("OPdump.Text", "System.Close  System.Copy  System.Grow  EdiT.Search"),
  51.             TextFrames.NewText(t, 0), TextFrames.menuH, x, y);
  52.         allocated:=TRUE
  53.     END OpenViewer;
  54.     PROCEDURE CheckOpen;
  55.     BEGIN
  56.         IF ~ allocated OR (v.state=0) THEN OpenViewer END
  57.     END CheckOpen;
  58.     PROCEDURE Ch*(ch: CHAR);
  59.     BEGIN CheckOpen; Texts.Write(w, ch); Texts.Append(t, w.buf)
  60.     END Ch;
  61.     PROCEDURE CheckScroll(t: Texts.Text);
  62.         VAR x: INTEGER; v: Viewers.Viewer; f: Display.Frame; f1:TextFrames.Frame; X,Y,W: INTEGER;
  63.     BEGIN
  64.         x := 0;
  65.         WHILE x < Display.Width DO
  66.             v := Viewers.This(x,0);
  67.             WHILE v.state>1 DO
  68.                 f := v.dsc;
  69.                 WHILE (f#NIL) & (f IS TextFrames.Frame) DO
  70.                     f1 := f(TextFrames.Frame);
  71.                     IF (f1.text = t) & (f1.H > 0) THEN
  72.                         X := f1.X; Y := f1.Y; W := f1.W;
  73.                         WHILE t.len > TextFrames.Pos(f1, X+W-1, Y+1) DO
  74.                             TextFrames.Show(f1, f1.org+1)
  75.                         END
  76.                     END ;
  77.                     f := f.next
  78.                 END ;
  79.                 v := Viewers.Next(v)
  80.             END ;
  81.             x := x + v.W
  82.         END
  83.     END CheckScroll;
  84.     PROCEDURE NL*;
  85.     BEGIN CheckOpen; Texts.WriteLn(w); Texts.Append(t, w.buf); CheckScroll(t)
  86.     END NL;
  87.     PROCEDURE Str*(s: ARRAY OF CHAR);
  88.         VAR i: INTEGER;
  89.     BEGIN CheckOpen;
  90.         i:=0;
  91.         WHILE (i <= LEN(s, 0)) & (s[i] # 0X) DO
  92.             IF s[i] = "$" THEN NL ELSE Texts.Write(w, s[i]) END ;
  93.             INC(i)
  94.         END ;
  95.         Texts.Append(t, w.buf)
  96.     END Str;
  97.     PROCEDURE LongInt*(i: LONGINT; n: INTEGER);
  98.     BEGIN CheckOpen;
  99.         IF i = MIN(LONGINT) THEN (* avoids TRAP 7 in Texts = bug *)
  100.             Str("-2147483648")
  101.         ELSE Texts.WriteInt(w, i, n)
  102.         END ;
  103.         Texts.Append(t, w.buf)
  104.     END LongInt;
  105.     PROCEDURE Hex*(i: LONGINT);
  106.     BEGIN CheckOpen; Texts.WriteHex(w, i); Texts.Append(t, w.buf)
  107.     END Hex;
  108.     PROCEDURE WReal*(r: REAL; n: INTEGER);
  109.     BEGIN CheckOpen; Texts.WriteReal(w, r, n); Texts.Append(t, w.buf)
  110.     END WReal;
  111.     PROCEDURE LongReal*(r: LONGREAL; n: INTEGER);
  112.     BEGIN CheckOpen; Texts.WriteLongReal(w, r, n); Texts.Append(t, w.buf)
  113.     END LongReal;
  114.     PROCEDURE BitSet*(s: SET);
  115.         VAR i, j: INTEGER; notfirst: BOOLEAN;
  116.     BEGIN i := 0; notfirst := FALSE; Ch("{");
  117.         WHILE i <= MAX(SET) DO
  118.             IF i IN s THEN
  119.                 IF notfirst THEN Str(", ")
  120.                 ELSE notfirst := TRUE
  121.                 END ;
  122.                 j := i; LongInt(i, 1); INC(i);
  123.                 WHILE (i <= MAX(SET)) & (i IN s) DO INC(i) END ;
  124.                 IF i-1 > j THEN
  125.                     IF i-2 = j THEN Str(", ") ELSE Str("..") END ;
  126.                     LongInt(i-1, 1)
  127.                 END
  128.             END ;
  129.             INC(i)
  130.         END ;
  131.         Ch("}")
  132.     END BitSet;
  133.     PROCEDURE Ptr(x: OPT.Node): INTEGER;
  134.         VAR i: INTEGER; n: LONGINT;
  135.     BEGIN
  136.         n := SYSTEM.ADR(x^); i := plx-1;
  137.         WHILE (i >= 0) & (pl[i] # n) DO DEC(i) END ;
  138.         IF i < 0 THEN pl[plx]:=n; i := plx; INC(plx) END ; 
  139.         RETURN i
  140.     END Ptr;
  141.     PROCEDURE Nr(x: OPT.Node);
  142.     BEGIN
  143.         Ch("["); LongInt(Ptr(x), 1); Str("] ")
  144.     END Nr;
  145.     PROCEDURE NrAndPos(x: OPT.Node);
  146.     BEGIN
  147.         Nr(x); Str("= "); Hex(SYSTEM.ADR(x^)); Str("  ")
  148.     END NrAndPos;
  149.     PROCEDURE Error(msg: ARRAY OF CHAR; x: OPT.Node);
  150.     BEGIN
  151.         Str("******error: "); Str(msg); Str(", class="); LongInt(x^.class, 1); NL
  152.     END Error;
  153.     PROCEDURE Left(x: OPT.Node);
  154.     BEGIN
  155.         Str("left=");
  156.         IF x^.left = NIL THEN Str("NIL ")
  157.         ELSE Nr(x^.left)
  158.         END
  159.     END Left;
  160.     PROCEDURE Right(x: OPT.Node);
  161.     BEGIN
  162.         Str("right=");
  163.         IF x^.right = NIL THEN Str("NIL ")
  164.         ELSE Nr(x^.right)
  165.         END
  166.     END Right;
  167.     PROCEDURE Link(x: OPT.Node);
  168.     BEGIN
  169.         Str("link=");
  170.         IF x^.link = NIL THEN Str("NIL ")
  171.         ELSE Nr(x^.link)
  172.         END
  173.     END Link;
  174.     PROCEDURE Type(x: OPT.Struct);
  175.     BEGIN
  176.         IF x^.comp = Basic THEN Str(typform[x^.form])
  177.         ELSE Str(typcomp[x^.comp])
  178.         END
  179.     END Type;
  180.     PROCEDURE NameAndType(x: OPT.Node);
  181.     BEGIN
  182.         Str(x^.obj^.name); Ch(" "); Type(x^.typ)
  183.     END NameAndType;
  184.     PROCEDURE conval*(x: OPT.Const; typ: OPT.Struct);
  185.         VAR r: REAL;
  186.     BEGIN
  187.         CASE typ^.form OF
  188.           Undef:
  189.         | Bool:
  190.                 IF x^.intval = 0 THEN Str("FALSE") ELSE Str("TRUE") END
  191.         | Char..LInt:
  192.                 LongInt(x^.intval, 1)
  193.         | Real:
  194.                 r := SHORT(x^.realval); WReal(r, 1)
  195.         | LReal:
  196.                 LongReal(x^.realval, 1)
  197.         | Set:
  198.                 BitSet(x^.setval)
  199.         | String:
  200.                 Str(" adr="); LongInt(x^.intval, 1);
  201.                 Str(" len="); LongInt(x^.intval2, 1)
  202.         | NilTyp:
  203.         END ;
  204.         Ch(" "); Str(typform[typ^.form])
  205.     END conval;
  206.     PROCEDURE^ expr*(x: OPT.Node; followlink: BOOLEAN);
  207.     PROCEDURE^ stat*(x: OPT.Node);
  208.     PROCEDURE design*(x: OPT.Node; nl: BOOLEAN);
  209.         PROCEDURE Leaf;
  210.         BEGIN
  211.             IF x^.obj^.mnolev >= 0 THEN
  212.                 IF x^.obj^.leaf THEN Str("leaf ")
  213.                 ELSE Str("~leaf ")
  214.                 END
  215.             END
  216.         END Leaf;
  217.     BEGIN
  218.         CASE x^.class OF
  219.           Nvar:
  220.                 NrAndPos(x); Str("Nvar "); Leaf; NameAndType(x)
  221.         | Nvarpar:
  222.                 NrAndPos(x); Str("Nvarpar "); Leaf; NameAndType(x)
  223.         | Nfield:
  224.                 design(x^.left, TRUE); NrAndPos(x); Str("Nfield "); NameAndType(x); Left(x)
  225.         | Nderef:
  226.                 design(x^.left, TRUE); NrAndPos(x); Str("Nderef "); Type(x^.typ); Left(x)
  227.         | Nindex:
  228.                 design(x^.left, TRUE); expr(x^.right, FALSE); NrAndPos(x); Str("Nindex "); Type(x^.typ); Left(x); Right(x)
  229.         | Nguard:
  230.                 design(x^.left, TRUE); NrAndPos(x); Str("Nguard ");
  231.                 IF x^.typ^.strobj # NIL THEN Str(x^.typ^.strobj^.name)
  232.                 ELSE Type(x^.typ)
  233.                 END ;
  234.                 Left(x)
  235.         | Neguard:
  236.                 design(x^.left, TRUE); NrAndPos(x); Str("Neguard ");
  237.                 IF x^.typ^.strobj # NIL THEN Str(x^.typ^.strobj^.name)
  238.                 ELSE Type(x^.typ)
  239.                 END ;
  240.                 Left(x)
  241.         | Ntype:
  242.                 NrAndPos(x); Str("Ntype "); NameAndType(x)
  243.         | Nproc:
  244.                 NrAndPos(x); Str("Nproc "); NameAndType(x)
  245.         ELSE NrAndPos(x); Error("design expected", x)
  246.         END ;
  247.         IF nl THEN NL END
  248.     END design;
  249.     PROCEDURE stat*(x: OPT.Node);
  250.         PROCEDURE CaseStat(x: OPT.Node);
  251.             VAR case: OPT.Node;
  252.         BEGIN
  253.             expr(x^.left, FALSE); case := x^.right^.left;
  254.             WHILE case # NIL DO
  255.                 expr(case^.left, TRUE); stat(case^.right);
  256.                 NrAndPos(case); Str("Ncasedo "); Left(case); Right(case); Link(case); NL;
  257.                 case := case^.link
  258.             END ;
  259.             stat(x^.right^.right);
  260.             NrAndPos(x^.right); Str("Ncaselse "); Left(x^.right); Right(x^.right); NL;
  261.             NrAndPos(x); Str("Ncase "); Left(x); Right(x)
  262.         END CaseStat;
  263.     BEGIN
  264.         WHILE x # NIL DO
  265.             CASE x^.class OF
  266.               Nenter:
  267.                     NrAndPos(x); Str("Nenter (entry) ");
  268.                     IF x^.obj = NIL THEN Str("module ")
  269.                     ELSE
  270.                         IF x^.obj^.leaf THEN Str("leaf ")
  271.                         ELSE Str("~leaf ")
  272.                         END ;
  273.                         Str("proc="); NameAndType(x); Str("mode="); Str(pmode[x^.obj^.mode])
  274.                     END ;
  275.                     NL;
  276.                     IF x^.left # NIL THEN stat(x^.left);
  277.                         NrAndPos(x); Str("Nenter (jump here) ");
  278.                         IF x^.obj = NIL THEN Str("module ")
  279.                         ELSE Str("proc="); NameAndType(x)
  280.                         END ;
  281.                         NL
  282.                     END ;
  283.                     stat(x^.right);
  284.                     NrAndPos(x); Str("Nenter (return from here) ");
  285.                     IF x^.obj = NIL THEN Str("module ")
  286.                     ELSE Str("proc="); NameAndType(x)
  287.                     END ;
  288.                     Left(x); Right(x)
  289.             | Ninittd:
  290.                     NrAndPos(x); Str("Ninittd ")
  291.             | Nassign:
  292.                     IF x^.subcl = movefn THEN
  293.                         expr(x^.left, FALSE); expr(x^.right, FALSE); expr(x^.right^.link, FALSE); NrAndPos(x);
  294.                         Str("Nassign movefn "); Left(x); Right(x); Str("Right-"); Link(x^.right)
  295.                     ELSE
  296.                         expr(x^.left, FALSE); IF x^.right # NIL THEN expr(x^.right, FALSE) END ;
  297.                         NrAndPos(x); Str("Nassign "); Str(fn[x^.subcl]);
  298.                         Left(x); Right(x)
  299.                     END
  300.             | Ncall:
  301.                     design(x^.left, TRUE); expr(x^.right, TRUE); NrAndPos(x); Str("Ncall "); Left(x); Right(x)
  302.             | Nifelse:
  303.                     stat(x^.left); stat(x^.right); NrAndPos(x); Str("Nifelse "); Left(x); Right(x)
  304.             | Nif:
  305.                     expr(x^.left, FALSE); stat(x^.right); NrAndPos(x); Str("Nif "); Left(x); Right(x)
  306.             | Ncase:
  307.                     CaseStat(x)
  308.             | Nwhile:
  309.                     expr(x^.left, FALSE); stat(x^.right); NrAndPos(x); Str("Nwhile "); Left(x); Right(x)
  310.             | Nrepeat:
  311.                     stat(x^.left); expr(x^.right, FALSE); NrAndPos(x); Str("Nrepeat "); Left(x); Right(x)
  312.             | Nloop:
  313.                     stat(x^.left); NrAndPos(x); Str("Nloop "); Left(x)
  314.             | Nexit:
  315.                     NrAndPos(x); Str("Nexit ")
  316.             | Nreturn:
  317.                     IF x^.left # NIL THEN expr(x^.left, FALSE) END ;
  318.                     NrAndPos(x); Str("Nreturn ");
  319.                     IF x^.obj = NIL THEN Str("module ")
  320.                     ELSE Str("proc="); NameAndType(x); Str("mode="); Str(pmode[x^.obj^.mode]);
  321.                         Str("psize="); conval(x^.obj^.conval, OPT.linttyp)
  322.                     END ;
  323.                     Left(x)
  324.             | Nwith:
  325.                     stat(x^.left); stat(x^.right); NrAndPos(x); Str("Nwith "); Left(x); Right(x)
  326.             | Ntrap:
  327.                     expr(x^.right, FALSE); NrAndPos(x); Str("Ntrap "); Right(x)
  328.             ELSE NrAndPos(x); Error("stat expected", x)
  329.             END ;
  330.             Link(x); NL; x := x^.link
  331.         END
  332.     END stat;
  333.     PROCEDURE expr*(x: OPT.Node; followlink: BOOLEAN);
  334.     BEGIN
  335.         IF x # NIL THEN
  336.             CASE x^.class OF
  337.               Nconst:
  338.                     NrAndPos(x); Str("Nconst "); conval(x^.conval, x^.typ)
  339.             | Nupto:
  340.                     expr(x^.left, FALSE); expr(x^.right, FALSE); NrAndPos(x); Str("Nupto ");
  341.                     Type(x^.typ); Left(x); Right(x)
  342.             | Nmop:
  343.                     expr(x^.left, FALSE); NrAndPos(x); Str("Nmop "); Str(op[x^.subcl]);
  344.                     IF x^.subcl = is THEN Str(x^.obj^.name); Ch(" "); Type(x^.obj^.typ) END ;
  345.                     Type(x^.typ); Left(x)
  346.             | Ndop:
  347.                     expr(x^.left, FALSE); expr(x^.right, FALSE); NrAndPos(x); Str("Ndop ");
  348.                     Str(op[x^.subcl]); Type(x^.typ); Left(x); Right(x)
  349.             | Ncall:
  350.                     design(x^.left, TRUE); expr(x^.right, TRUE); NrAndPos(x); Str("Ncall ");
  351.                     Type(x^.typ); Left(x); Right(x)
  352.             ELSE design(x, FALSE)
  353.             END ;
  354.             IF followlink THEN Link(x) END ;
  355.             NL;
  356.             IF followlink THEN expr(x^.link, TRUE) END
  357.         END
  358.     END expr;
  359.     PROCEDURE Init;
  360.         VAR i: INTEGER;
  361.     BEGIN i := 0;
  362.         WHILE i < LEN(pmode) DO COPY("****** ", pmode[i]); INC(i) END ;
  363.         COPY("LProc ", pmode[LProc]);
  364.         COPY("XProc ", pmode[XProc]);
  365.         COPY("IProc ", pmode[IProc]);
  366.         COPY("Mod ", pmode[Mod]);
  367.         COPY("TProc ", pmode[TProc]);
  368.         i := 0;
  369.         WHILE i < LEN(typform) DO COPY("****** ", typform[i]); INC(i) END ;
  370.         COPY("Undef ", typform[Undef]);
  371.         COPY("Byte ", typform[Byte]);
  372.         COPY("Bool ", typform[Bool]);
  373.         COPY("Char ", typform[Char]);
  374.         COPY("SInt ", typform[SInt]);
  375.         COPY("Int ", typform[Int]);
  376.         COPY("LInt ", typform[LInt]);
  377.         COPY("Real ", typform[Real]);
  378.         COPY("LReal ", typform[LReal]);
  379.         COPY("Set ", typform[Set]);
  380.         COPY("String ", typform[String]);
  381.         COPY("NilTyp ", typform[NilTyp]);
  382.         COPY("NoTyp ", typform[NoTyp]);
  383.         COPY("Pointer ", typform[Pointer]);
  384.         COPY("ProcTyp ", typform[ProcTyp]);
  385.         i := 0;
  386.         WHILE i < LEN(typcomp) DO COPY("****** ", typcomp[i]); INC(i) END ;
  387.         COPY("Array ", typcomp[Array]);
  388.         COPY("DynArr ", typcomp[DynArr]);
  389.         COPY("Record ", typcomp[Record]);
  390.         i := 0;
  391.         WHILE i < LEN(op) DO COPY("****** ", op[i]); INC(i) END ;
  392.         COPY("times ", op[times]);
  393.         COPY("slash ", op[slash]);
  394.         COPY("div ", op[div]);
  395.         COPY("mod ", op[mod]);
  396.         COPY("and ", op[and]);
  397.         COPY("plus ", op[plus]);
  398.         COPY("minus ", op[minus]);
  399.         COPY("or ", op[or]);
  400.         COPY("eql ", op[eql]);
  401.         COPY("neq ", op[neq]);
  402.         COPY("lss ", op[lss]);
  403.         COPY("leq ", op[leq]);
  404.         COPY("gtr ", op[gtr]);
  405.         COPY("geq ", op[geq]);
  406.         COPY("in ", op[in]);
  407.         COPY("is ", op[is]);
  408.         COPY("ash ", op[ash]);
  409.         COPY("msk ", op[msk]);
  410.         COPY("len ", op[len]);
  411.         COPY("conv ", op[conv]);
  412.         COPY("abs ", op[abs]);
  413.         COPY("cap ", op[cap]);
  414.         COPY("odd ", op[odd]);
  415.         COPY("adr ", op[adr]);
  416.         COPY("not ", op[not]);
  417.         COPY("cc ", op[cc]);
  418.         COPY("bit ", op[bit]);
  419.         COPY("lsh ", op[lsh]);
  420.         COPY("rot ", op[rot]);
  421.         COPY("val ", op[val]);
  422.         i := 0;
  423.         WHILE i < LEN(fn) DO COPY("****** ", fn[i]); INC(i) END ;
  424.         COPY("assign ", fn[assign]);
  425.         COPY("newfn ", fn[newfn]);
  426.         COPY("incfn ", fn[incfn]);
  427.         COPY("decfn ", fn[decfn]);
  428.         COPY("inclfn ", fn[inclfn]);
  429.         COPY("exclfn ", fn[exclfn]);
  430.         COPY("copyfn ", fn[copyfn]);
  431.         COPY("getfn ", fn[getfn]);
  432.         COPY("putfn ", fn[putfn]);
  433.         COPY("getrfn ", fn[getrfn]);
  434.         COPY("putrfn ", fn[putrfn]);
  435.         COPY("sysnewfn ", fn[sysnewfn]);
  436.         COPY("movefn ", fn[movefn]);
  437.     END Init;
  438.     PROCEDURE Reset*;
  439.     BEGIN plx := 0
  440.     END Reset;
  441.     PROCEDURE Show*;    (* hexa number as param = node pointer *)
  442.         VAR par: Oberon.ParList; t: Texts.Text; s: Texts.Scanner; i: INTEGER; n: OPT.Node;
  443.     BEGIN
  444.         par := Oberon.Par; t := par.frame(TextFrames.Frame).text;
  445.         Texts.OpenScanner(s, t, par.pos); Texts.Scan(s);
  446.         IF s.class = 3 THEN  (*integer*)
  447.             n := SYSTEM.VAL(OPT.Node, s.i);
  448.             IF plx = 0 THEN
  449.                 CASE n^.class OF
  450.                   Nvar..Neguard, Ntype..Nproc:
  451.                         design(n, TRUE)
  452.                 | Nconst, Nupto..Ncall:
  453.                         expr(n, FALSE)
  454.                 | Ninittd..Ntrap:
  455.                         stat(n)
  456.                 ELSE Str("******* not a node, class = "); LongInt(n^.class, 1)
  457.                 END
  458.             ELSE i := Ptr(n);
  459.                 IF i = plx - 1 THEN Str("******* not defined")
  460.                 ELSE Hex(s.i); Str(" = ["); LongInt(i, 1); Str("] ")
  461.                 END
  462.             END ;
  463.             NL
  464.         END
  465.     END Show;
  466.     PROCEDURE ShowProg*;
  467.     BEGIN stat(OP2.prog)
  468.     END ShowProg;
  469. BEGIN Init; Reset; allocated := FALSE; Texts.OpenWriter(w)
  470. END POPdump.
  471.